<?xml version="1.0" encoding="iso-8859-1"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
          "DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
<head>
  <title>__builtin__.dict</title>
  <link rel="stylesheet" href="epydoc.css" type="text/css"></link>
</head>
<body bgcolor="white" text="black" link="blue" vlink="#204080"
      alink="#204080">

<!-- =========== START OF NAVBAR =========== -->
<table class="navbar" border="0" width="100%" cellpadding="0" bgcolor="#a0c0ff" cellspacing="0">
  <tr valign="center">
    <th class="navbar">&nbsp;&nbsp;&nbsp;<a class="navbar" href="gvn-module.html">Home</a>&nbsp;&nbsp;&nbsp;</th>
    <th class="navbar">&nbsp;&nbsp;&nbsp;<a class="navbar" href="trees.html">Trees</a>&nbsp;&nbsp;&nbsp;</th>
    <th class="navbar">&nbsp;&nbsp;&nbsp;<a class="navbar" href="indices.html">Index</a>&nbsp;&nbsp;&nbsp;</th>
    <th class="navbar">&nbsp;&nbsp;&nbsp;<a class="navbar" href="help.html">Help</a>&nbsp;&nbsp;&nbsp;</th>
    <th class="navbar" align="right" width="100%">
      <table border="0" cellpadding="0" cellspacing="0">
      <tr><th class="navbar" align="center">
        <p class="nomargin">
          <a class="navbar" target="_top" href="http://code.google.com/p/gvn/">Project&nbsp;Homepage</a>
      </p></th></tr></table>
    </th>
  </tr>
</table>
<table width="100%" cellpadding="0" cellspacing="0">
  <tr valign="top">
    <td width="100%">
      <font size="-1"><b class="breadcrumbs">
        Module&nbsp;__builtin__ ::
        Class&nbsp;dict
      </b></font></br>
    </td>
    <td><table cellpadding="0" cellspacing="0">
      <tr><td align="right"><font size="-2">[<a href="../private/__builtin__.dict-class.html">show&nbsp;private</a>&nbsp;|&nbsp;hide&nbsp;private]</font></td></tr>
      <tr><td align="right"><font size="-2">[<a href="frames.html"target="_top">frames</a>&nbsp;|&nbsp;<a href="__builtin__.dict-class.html" target="_top">no&nbsp;frames</a>]</font></td></tr>
    </table></td>
</tr></table>

<!-- =========== START OF CLASS DESCRIPTION =========== -->
<h2 class="class">Type dict</h2>

<pre class="base-tree">
<a href="__builtin__.object-class.html"><code>object</code></a> --+
         |
        <b>dict</b>
</pre><br />

<dl><dt><b>Known Subclasses:</b></dt>
<dd>
    <a href="gvn.util.ListDict-class.html"><code>ListDict</code></a></dd></dl>

<hr/>

<pre class="literalblock">
dict() -&gt; new empty dictionary.
dict(mapping) -&gt; new dictionary initialized from a mapping object's
    (key, value) pairs.
dict(seq) -&gt; new dictionary initialized as if via:
    d = {}
    for k, v in seq:
        d[k] = v
dict(**kwargs) -&gt; new dictionary initialized with the name=value pairs
    in the keyword argument list.  For example:  dict(one=1, two=2)
</pre>
<hr/>


<!-- =========== START OF METHOD SUMMARY =========== -->
<table class="summary" border="1" cellpadding="3" cellspacing="0" width="100%" bgcolor="white">
<tr bgcolor="#70b0f0" class="summary">
  <th colspan="2">Method Summary</th></tr>
<tr><td align="right" valign="top" width="15%"><font size="-1">&nbsp;</font></td>
  <td><code><span class="summary-sig"><a href="__builtin__.dict-class.html#__init__" class="summary-sig-name"><code>__init__</code></a>(<span class="summary-sig-vararg">...</span>)</span></code>
<br />
x.__init__(...) initializes x; see x.__class__.__doc__ for 
signature</td></tr>
<tr><td align="right" valign="top" width="15%"><font size="-1">&nbsp;</font></td>
  <td><code><span class="summary-sig"><a href="__builtin__.dict-class.html#__cmp__" class="summary-sig-name"><code>__cmp__</code></a>(<span class=summary-sig-arg>x</span>,
          <span class=summary-sig-arg>y</span>)</span></code>
<br />
x.__cmp__(y) &lt;==&gt; cmp(x,y)</td></tr>
<tr><td align="right" valign="top" width="15%"><font size="-1">&nbsp;</font></td>
  <td><code><span class="summary-sig"><a href="__builtin__.dict-class.html#__contains__" class="summary-sig-name"><code>__contains__</code></a>(<span class=summary-sig-arg>D</span>,
          <span class=summary-sig-arg>k</span>)</span></code>
<br />
D.__contains__(k) -&gt; True if D has a key k, else False</td></tr>
<tr><td align="right" valign="top" width="15%"><font size="-1">&nbsp;</font></td>
  <td><code><span class="summary-sig"><a href="__builtin__.dict-class.html#__delitem__" class="summary-sig-name"><code>__delitem__</code></a>(<span class=summary-sig-arg>x</span>,
          <span class=summary-sig-arg>y</span>)</span></code>
<br />
x.__delitem__(y) &lt;==&gt; del x[y]</td></tr>
<tr><td align="right" valign="top" width="15%"><font size="-1">&nbsp;</font></td>
  <td><code><span class="summary-sig"><a href="__builtin__.dict-class.html#__eq__" class="summary-sig-name"><code>__eq__</code></a>(<span class=summary-sig-arg>x</span>,
          <span class=summary-sig-arg>y</span>)</span></code>
<br />
x.__eq__(y) &lt;==&gt; x==y</td></tr>
<tr><td align="right" valign="top" width="15%"><font size="-1">&nbsp;</font></td>
  <td><code><span class="summary-sig"><a href="__builtin__.dict-class.html#__ge__" class="summary-sig-name"><code>__ge__</code></a>(<span class=summary-sig-arg>x</span>,
          <span class=summary-sig-arg>y</span>)</span></code>
<br />
x.__ge__(y) &lt;==&gt; x&gt;=y</td></tr>
<tr><td align="right" valign="top" width="15%"><font size="-1">&nbsp;</font></td>
  <td><code><span class="summary-sig"><a href="__builtin__.dict-class.html#__getattribute__" class="summary-sig-name"><code>__getattribute__</code></a>(<span class="summary-sig-vararg">...</span>)</span></code>
<br />
x.__getattribute__('name') &lt;==&gt; x.name</td></tr>
<tr><td align="right" valign="top" width="15%"><font size="-1">&nbsp;</font></td>
  <td><code><span class="summary-sig"><a href="__builtin__.dict-class.html#__getitem__" class="summary-sig-name"><code>__getitem__</code></a>(<span class=summary-sig-arg>x</span>,
          <span class=summary-sig-arg>y</span>)</span></code>
<br />
x.__getitem__(y) &lt;==&gt; x[y]</td></tr>
<tr><td align="right" valign="top" width="15%"><font size="-1">&nbsp;</font></td>
  <td><code><span class="summary-sig"><a href="__builtin__.dict-class.html#__gt__" class="summary-sig-name"><code>__gt__</code></a>(<span class=summary-sig-arg>x</span>,
          <span class=summary-sig-arg>y</span>)</span></code>
<br />
x.__gt__(y) &lt;==&gt; x&gt;y</td></tr>
<tr><td align="right" valign="top" width="15%"><font size="-1">&nbsp;</font></td>
  <td><code><span class="summary-sig"><a href="__builtin__.dict-class.html#__hash__" class="summary-sig-name"><code>__hash__</code></a>(<span class=summary-sig-arg>x</span>)</span></code>
<br />
x.__hash__() &lt;==&gt; hash(x)</td></tr>
<tr><td align="right" valign="top" width="15%"><font size="-1">&nbsp;</font></td>
  <td><code><span class="summary-sig"><a href="__builtin__.dict-class.html#__iter__" class="summary-sig-name"><code>__iter__</code></a>(<span class=summary-sig-arg>x</span>)</span></code>
<br />
x.__iter__() &lt;==&gt; iter(x)</td></tr>
<tr><td align="right" valign="top" width="15%"><font size="-1">&nbsp;</font></td>
  <td><code><span class="summary-sig"><a href="__builtin__.dict-class.html#__le__" class="summary-sig-name"><code>__le__</code></a>(<span class=summary-sig-arg>x</span>,
          <span class=summary-sig-arg>y</span>)</span></code>
<br />
x.__le__(y) &lt;==&gt; x&lt;=y</td></tr>
<tr><td align="right" valign="top" width="15%"><font size="-1">&nbsp;</font></td>
  <td><code><span class="summary-sig"><a href="__builtin__.dict-class.html#__len__" class="summary-sig-name"><code>__len__</code></a>(<span class=summary-sig-arg>x</span>)</span></code>
<br />
x.__len__() &lt;==&gt; len(x)</td></tr>
<tr><td align="right" valign="top" width="15%"><font size="-1">&nbsp;</font></td>
  <td><code><span class="summary-sig"><a href="__builtin__.dict-class.html#__lt__" class="summary-sig-name"><code>__lt__</code></a>(<span class=summary-sig-arg>x</span>,
          <span class=summary-sig-arg>y</span>)</span></code>
<br />
x.__lt__(y) &lt;==&gt; x&lt;y</td></tr>
<tr><td align="right" valign="top" width="15%"><font size="-1">&nbsp;</font></td>
  <td><code><span class="summary-sig"><a href="__builtin__.dict-class.html#__ne__" class="summary-sig-name"><code>__ne__</code></a>(<span class=summary-sig-arg>x</span>,
          <span class=summary-sig-arg>y</span>)</span></code>
<br />
x.__ne__(y) &lt;==&gt; x!=y</td></tr>
<tr><td align="right" valign="top" width="15%"><font size="-1">&nbsp;</font></td>
  <td><code><span class="summary-sig"><a href="__builtin__.dict-class.html#__new__" class="summary-sig-name"><code>__new__</code></a>(<span class=summary-sig-arg>T</span>,
          <span class=summary-sig-arg>S</span>,
          <span class="summary-sig-vararg">...</span>)</span></code>
<br />
T.__new__(S, ...) -&gt; a new object with type S, a subtype of T</td></tr>
<tr><td align="right" valign="top" width="15%"><font size="-1">&nbsp;</font></td>
  <td><code><span class="summary-sig"><a href="__builtin__.dict-class.html#__repr__" class="summary-sig-name"><code>__repr__</code></a>(<span class=summary-sig-arg>x</span>)</span></code>
<br />
x.__repr__() &lt;==&gt; repr(x)</td></tr>
<tr><td align="right" valign="top" width="15%"><font size="-1">&nbsp;</font></td>
  <td><code><span class="summary-sig"><a href="__builtin__.dict-class.html#__setitem__" class="summary-sig-name"><code>__setitem__</code></a>(<span class=summary-sig-arg>x</span>,
          <span class=summary-sig-arg>i</span>,
          <span class=summary-sig-arg>y</span>)</span></code>
<br />
x.__setitem__(i, y) &lt;==&gt; x[i]=y</td></tr>
<tr><td align="right" valign="top" width="15%"><font size="-1">&nbsp;</font></td>
  <td><code><span class="summary-sig"><a href="__builtin__.dict-class.html#clear" class="summary-sig-name"><code>clear</code></a>(<span class=summary-sig-arg>D</span>)</span></code>
<br />
D.clear() -&gt; None.</td></tr>
<tr><td align="right" valign="top" width="15%"><font size="-1">&nbsp;</font></td>
  <td><code><span class="summary-sig"><a href="__builtin__.dict-class.html#copy" class="summary-sig-name"><code>copy</code></a>(<span class=summary-sig-arg>D</span>)</span></code>
<br />
D.copy() -&gt; a shallow copy of D</td></tr>
<tr><td align="right" valign="top" width="15%"><font size="-1">&nbsp;</font></td>
  <td><code><span class="summary-sig"><a href="__builtin__.dict-class.html#get" class="summary-sig-name"><code>get</code></a>(<span class=summary-sig-arg>D</span>,
          <span class=summary-sig-arg>k</span>,
          <span class=summary-sig-arg>d</span>)</span></code>
<br />
D.get(k[,d]) -&gt; D[k] if k in D, else d.</td></tr>
<tr><td align="right" valign="top" width="15%"><font size="-1">&nbsp;</font></td>
  <td><code><span class="summary-sig"><a href="__builtin__.dict-class.html#has_key" class="summary-sig-name"><code>has_key</code></a>(<span class=summary-sig-arg>D</span>,
          <span class=summary-sig-arg>k</span>)</span></code>
<br />
D.has_key(k) -&gt; True if D has a key k, else False</td></tr>
<tr><td align="right" valign="top" width="15%"><font size="-1">&nbsp;</font></td>
  <td><code><span class="summary-sig"><a href="__builtin__.dict-class.html#items" class="summary-sig-name"><code>items</code></a>(<span class=summary-sig-arg>D</span>)</span></code>
<br />
D.items() -&gt; list of D's (key, value) pairs, as 2-tuples</td></tr>
<tr><td align="right" valign="top" width="15%"><font size="-1">&nbsp;</font></td>
  <td><code><span class="summary-sig"><a href="__builtin__.dict-class.html#iteritems" class="summary-sig-name"><code>iteritems</code></a>(<span class=summary-sig-arg>D</span>)</span></code>
<br />
D.iteritems() -&gt; an iterator over the (key, value) items of D</td></tr>
<tr><td align="right" valign="top" width="15%"><font size="-1">&nbsp;</font></td>
  <td><code><span class="summary-sig"><a href="__builtin__.dict-class.html#iterkeys" class="summary-sig-name"><code>iterkeys</code></a>(<span class=summary-sig-arg>D</span>)</span></code>
<br />
D.iterkeys() -&gt; an iterator over the keys of D</td></tr>
<tr><td align="right" valign="top" width="15%"><font size="-1">&nbsp;</font></td>
  <td><code><span class="summary-sig"><a href="__builtin__.dict-class.html#itervalues" class="summary-sig-name"><code>itervalues</code></a>(<span class=summary-sig-arg>D</span>)</span></code>
<br />
D.itervalues() -&gt; an iterator over the values of D</td></tr>
<tr><td align="right" valign="top" width="15%"><font size="-1">&nbsp;</font></td>
  <td><code><span class="summary-sig"><a href="__builtin__.dict-class.html#keys" class="summary-sig-name"><code>keys</code></a>(<span class=summary-sig-arg>D</span>)</span></code>
<br />
D.keys() -&gt; list of D's keys</td></tr>
<tr><td align="right" valign="top" width="15%"><font size="-1">&nbsp;</font></td>
  <td><code><span class="summary-sig"><a href="__builtin__.dict-class.html#pop" class="summary-sig-name"><code>pop</code></a>(<span class=summary-sig-arg>D</span>,
          <span class=summary-sig-arg>k</span>,
          <span class=summary-sig-arg>d</span>)</span></code>
<br />
If key is not found, d is returned if given, otherwise KeyError is 
raised</td></tr>
<tr><td align="right" valign="top" width="15%"><font size="-1">&nbsp;</font></td>
  <td><code><span class="summary-sig"><a href="__builtin__.dict-class.html#popitem" class="summary-sig-name"><code>popitem</code></a>(<span class=summary-sig-arg>D</span>)</span></code>
<br />
2-tuple; but raise KeyError if D is empty</td></tr>
<tr><td align="right" valign="top" width="15%"><font size="-1">&nbsp;</font></td>
  <td><code><span class="summary-sig"><a href="__builtin__.dict-class.html#setdefault" class="summary-sig-name"><code>setdefault</code></a>(<span class=summary-sig-arg>D</span>,
          <span class=summary-sig-arg>k</span>,
          <span class=summary-sig-arg>d</span>)</span></code>
<br />
D.setdefault(k[,d]) -&gt; D.get(k,d), also set D[k]=d if k not in 
D</td></tr>
<tr><td align="right" valign="top" width="15%"><font size="-1">&nbsp;</font></td>
  <td><code><span class="summary-sig"><a href="__builtin__.dict-class.html#update" class="summary-sig-name"><code>update</code></a>(<span class="summary-sig-vararg">...</span>)</span></code>
<br />
D.update(E, **F) -&gt; None.</td></tr>
<tr><td align="right" valign="top" width="15%"><font size="-1">&nbsp;</font></td>
  <td><code><span class="summary-sig"><a href="__builtin__.dict-class.html#values" class="summary-sig-name"><code>values</code></a>(<span class=summary-sig-arg>D</span>)</span></code>
<br />
D.values() -&gt; list of D's values</td></tr>
<tr bgcolor="#e8f0f8" class="group">
  <th colspan="2">&nbsp;&nbsp;&nbsp;&nbsp;Inherited from object</th></tr>
<tr><td align="right" valign="top" width="15%"><font size="-1">&nbsp;</font></td>
  <td><code><span class="summary-sig"><a href="__builtin__.object-class.html#__delattr__" class="summary-sig-name"><code>__delattr__</code></a>(<span class="summary-sig-vararg">...</span>)</span></code>
<br />
x.__delattr__('name') &lt;==&gt; del x.name</td></tr>
<tr><td align="right" valign="top" width="15%"><font size="-1">&nbsp;</font></td>
  <td><code><span class="summary-sig"><a href="__builtin__.object-class.html#__reduce__" class="summary-sig-name"><code>__reduce__</code></a>(<span class="summary-sig-vararg">...</span>)</span></code>
<br />
helper for pickle</td></tr>
<tr><td align="right" valign="top" width="15%"><font size="-1">&nbsp;</font></td>
  <td><code><span class="summary-sig"><a href="__builtin__.object-class.html#__reduce_ex__" class="summary-sig-name"><code>__reduce_ex__</code></a>(<span class="summary-sig-vararg">...</span>)</span></code>
<br />
helper for pickle</td></tr>
<tr><td align="right" valign="top" width="15%"><font size="-1">&nbsp;</font></td>
  <td><code><span class="summary-sig"><a href="__builtin__.object-class.html#__setattr__" class="summary-sig-name"><code>__setattr__</code></a>(<span class="summary-sig-vararg">...</span>)</span></code>
<br />
x.__setattr__('name', value) &lt;==&gt; x.name = value</td></tr>
<tr><td align="right" valign="top" width="15%"><font size="-1">&nbsp;</font></td>
  <td><code><span class="summary-sig"><a href="__builtin__.object-class.html#__str__" class="summary-sig-name"><code>__str__</code></a>(<span class=summary-sig-arg>x</span>)</span></code>
<br />
x.__str__() &lt;==&gt; str(x)</td></tr>
<tr bgcolor="#e8f0f8" class="group">
  <th colspan="2">&nbsp;&nbsp;&nbsp;&nbsp;Inherited from type</th></tr>
<tr><td align="right" valign="top" width="15%"><font size="-1">&nbsp;</font></td>
  <td><code><span class="summary-sig"><a href="__builtin__.type-class.html#fromkeys" class="summary-sig-name"><code>fromkeys</code></a>(<span class=summary-sig-arg>dict</span>,
          <span class=summary-sig-arg>S</span>,
          <span class=summary-sig-arg>v</span>)</span></code>
<br />
v defaults to None.</td></tr>
</table><br />


<!-- =========== START OF METHOD DETAILS =========== -->
<table class="details" border="1" cellpadding="3" cellspacing="0" width="100%" bgcolor="white">
<tr bgcolor="#70b0f0" class="details">
  <th colspan="2">Method Details</th></tr>
</table>

<a name="__init__"></a>
<table width="100%" class="func-details" bgcolor="#e0e0e0"><tr><td>
  <h3><span class="sig"><span class="sig-name">__init__</span>(<span class="sig-vararg">...</span>)</span>
    <br /><i>(Constructor)</i>
  </h3>
  x.__init__(...) initializes x; see x.__class__.__doc__ for 
  signature
  <dl><dt></dt><dd>
    <dl><dt><b>Overrides:</b></dt>
      <dd><a href="__builtin__.object-class.html#__init__"><code>__builtin__.object.__init__</code></a></dd>
    </dl>
  </dd></dl>
</td></tr></table>

<a name="__cmp__"></a>
<table width="100%" class="func-details" bgcolor="#e0e0e0"><tr><td>
  <h3><span class="sig"><span class="sig-name">__cmp__</span>(<span class=sig-arg>x</span>,
          <span class=sig-arg>y</span>)</span>
    <br /><i>(Comparison operator)</i>
  </h3>
  x.__cmp__(y) &lt;==&gt; cmp(x,y)
  <dl><dt></dt><dd>
    <dl><dt><b>Returns:</b></dt>
      <dd>
<pre class="literalblock">
cmp(x,y)
</pre>
      </dd>
    </dl>
  </dd></dl>
</td></tr></table>

<a name="__contains__"></a>
<table width="100%" class="func-details" bgcolor="#e0e0e0"><tr><td>
  <h3><span class="sig"><span class="sig-name">__contains__</span>(<span class=sig-arg>D</span>,
          <span class=sig-arg>k</span>)</span>
    <br /><i>(In operator)</i>
  </h3>
  D.__contains__(k) -&gt; True if D has a key k, else False
  <dl><dt></dt><dd>
    <dl><dt><b>Returns:</b></dt>
      <dd>
<pre class="literalblock">
True if D has a key k, else False
</pre>
      </dd>
    </dl>
  </dd></dl>
</td></tr></table>

<a name="__delitem__"></a>
<table width="100%" class="func-details" bgcolor="#e0e0e0"><tr><td>
  <h3><span class="sig"><span class="sig-name">__delitem__</span>(<span class=sig-arg>x</span>,
          <span class=sig-arg>y</span>)</span>
    <br /><i>(Index deletion operator)</i>
  </h3>
  x.__delitem__(y) &lt;==&gt; del x[y]
  <dl><dt></dt><dd>
    <dl><dt><b>Returns:</b></dt>
      <dd>
<pre class="literalblock">
del x[y]
</pre>
      </dd>
    </dl>
  </dd></dl>
</td></tr></table>

<a name="__eq__"></a>
<table width="100%" class="func-details" bgcolor="#e0e0e0"><tr><td>
  <h3><span class="sig"><span class="sig-name">__eq__</span>(<span class=sig-arg>x</span>,
          <span class=sig-arg>y</span>)</span>
    <br /><i>(Equality operator)</i>
  </h3>
  x.__eq__(y) &lt;==&gt; x==y
  <dl><dt></dt><dd>
    <dl><dt><b>Returns:</b></dt>
      <dd>
<pre class="literalblock">
x==y
</pre>
      </dd>
    </dl>
  </dd></dl>
</td></tr></table>

<a name="__ge__"></a>
<table width="100%" class="func-details" bgcolor="#e0e0e0"><tr><td>
  <h3><span class="sig"><span class="sig-name">__ge__</span>(<span class=sig-arg>x</span>,
          <span class=sig-arg>y</span>)</span>
    <br /><i>(Greater-than-or-equals operator)</i>
  </h3>
  x.__ge__(y) &lt;==&gt; x&gt;=y
  <dl><dt></dt><dd>
    <dl><dt><b>Returns:</b></dt>
      <dd>
<pre class="literalblock">
x&gt;=y
</pre>
      </dd>
    </dl>
  </dd></dl>
</td></tr></table>

<a name="__getattribute__"></a>
<table width="100%" class="func-details" bgcolor="#e0e0e0"><tr><td>
  <h3><span class="sig"><span class="sig-name">__getattribute__</span>(<span class="sig-vararg">...</span>)</span>
  </h3>
  x.__getattribute__('name') &lt;==&gt; x.name
  <dl><dt></dt><dd>
    <dl><dt><b>Overrides:</b></dt>
      <dd><a href="__builtin__.object-class.html#__getattribute__"><code>__builtin__.object.__getattribute__</code></a></dd>
    </dl>
  </dd></dl>
</td></tr></table>

<a name="__getitem__"></a>
<table width="100%" class="func-details" bgcolor="#e0e0e0"><tr><td>
  <h3><span class="sig"><span class="sig-name">__getitem__</span>(<span class=sig-arg>x</span>,
          <span class=sig-arg>y</span>)</span>
    <br /><i>(Indexing operator)</i>
  </h3>
  x.__getitem__(y) &lt;==&gt; x[y]
  <dl><dt></dt><dd>
    <dl><dt><b>Returns:</b></dt>
      <dd>
<pre class="literalblock">
x[y]
</pre>
      </dd>
    </dl>
  </dd></dl>
</td></tr></table>

<a name="__gt__"></a>
<table width="100%" class="func-details" bgcolor="#e0e0e0"><tr><td>
  <h3><span class="sig"><span class="sig-name">__gt__</span>(<span class=sig-arg>x</span>,
          <span class=sig-arg>y</span>)</span>
    <br /><i>(Greater-than operator)</i>
  </h3>
  x.__gt__(y) &lt;==&gt; x&gt;y
  <dl><dt></dt><dd>
    <dl><dt><b>Returns:</b></dt>
      <dd>
<pre class="literalblock">
x&gt;y
</pre>
      </dd>
    </dl>
  </dd></dl>
</td></tr></table>

<a name="__hash__"></a>
<table width="100%" class="func-details" bgcolor="#e0e0e0"><tr><td>
  <h3><span class="sig"><span class="sig-name">__hash__</span>(<span class=sig-arg>x</span>)</span>
    <br /><i>(Hashing function)</i>
  </h3>
  x.__hash__() &lt;==&gt; hash(x)
  <dl><dt></dt><dd>
    <dl><dt><b>Returns:</b></dt>
      <dd>
<pre class="literalblock">
hash(x)
</pre>
      </dd>
    </dl>
    <dl><dt><b>Overrides:</b></dt>
      <dd><a href="__builtin__.object-class.html#__hash__"><code>__builtin__.object.__hash__</code></a></dd>
    </dl>
  </dd></dl>
</td></tr></table>

<a name="__iter__"></a>
<table width="100%" class="func-details" bgcolor="#e0e0e0"><tr><td>
  <h3><span class="sig"><span class="sig-name">__iter__</span>(<span class=sig-arg>x</span>)</span>
  </h3>
  x.__iter__() &lt;==&gt; iter(x)
  <dl><dt></dt><dd>
    <dl><dt><b>Returns:</b></dt>
      <dd>
<pre class="literalblock">
iter(x)
</pre>
      </dd>
    </dl>
  </dd></dl>
</td></tr></table>

<a name="__le__"></a>
<table width="100%" class="func-details" bgcolor="#e0e0e0"><tr><td>
  <h3><span class="sig"><span class="sig-name">__le__</span>(<span class=sig-arg>x</span>,
          <span class=sig-arg>y</span>)</span>
    <br /><i>(Less-than-or-equals operator)</i>
  </h3>
  x.__le__(y) &lt;==&gt; x&lt;=y
  <dl><dt></dt><dd>
    <dl><dt><b>Returns:</b></dt>
      <dd>
<pre class="literalblock">
x&lt;=y
</pre>
      </dd>
    </dl>
  </dd></dl>
</td></tr></table>

<a name="__len__"></a>
<table width="100%" class="func-details" bgcolor="#e0e0e0"><tr><td>
  <h3><span class="sig"><span class="sig-name">__len__</span>(<span class=sig-arg>x</span>)</span>
    <br /><i>(Length operator)</i>
  </h3>
  x.__len__() &lt;==&gt; len(x)
  <dl><dt></dt><dd>
    <dl><dt><b>Returns:</b></dt>
      <dd>
<pre class="literalblock">
len(x)
</pre>
      </dd>
    </dl>
  </dd></dl>
</td></tr></table>

<a name="__lt__"></a>
<table width="100%" class="func-details" bgcolor="#e0e0e0"><tr><td>
  <h3><span class="sig"><span class="sig-name">__lt__</span>(<span class=sig-arg>x</span>,
          <span class=sig-arg>y</span>)</span>
    <br /><i>(Less-than operator)</i>
  </h3>
  x.__lt__(y) &lt;==&gt; x&lt;y
  <dl><dt></dt><dd>
    <dl><dt><b>Returns:</b></dt>
      <dd>
<pre class="literalblock">
x&lt;y
</pre>
      </dd>
    </dl>
  </dd></dl>
</td></tr></table>

<a name="__ne__"></a>
<table width="100%" class="func-details" bgcolor="#e0e0e0"><tr><td>
  <h3><span class="sig"><span class="sig-name">__ne__</span>(<span class=sig-arg>x</span>,
          <span class=sig-arg>y</span>)</span>
  </h3>
  x.__ne__(y) &lt;==&gt; x!=y
  <dl><dt></dt><dd>
    <dl><dt><b>Returns:</b></dt>
      <dd>
<pre class="literalblock">
x!=y
</pre>
      </dd>
    </dl>
  </dd></dl>
</td></tr></table>

<a name="__new__"></a>
<table width="100%" class="func-details" bgcolor="#e0e0e0"><tr><td>
  <h3><span class="sig"><span class="sig-name">__new__</span>(<span class=sig-arg>T</span>,
          <span class=sig-arg>S</span>,
          <span class="sig-vararg">...</span>)</span>
  </h3>
  T.__new__(S, ...) -&gt; a new object with type S, a subtype of T
  <dl><dt></dt><dd>
    <dl><dt><b>Returns:</b></dt>
      <dd>
<pre class="literalblock">
a new object with type S, a subtype of T
</pre>
      </dd>
    </dl>
    <dl><dt><b>Overrides:</b></dt>
      <dd><a href="__builtin__.object-class.html#__new__"><code>__builtin__.object.__new__</code></a></dd>
    </dl>
  </dd></dl>
</td></tr></table>

<a name="__repr__"></a>
<table width="100%" class="func-details" bgcolor="#e0e0e0"><tr><td>
  <h3><span class="sig"><span class="sig-name">__repr__</span>(<span class=sig-arg>x</span>)</span>
    <br /><i>(Representation operator)</i>
  </h3>
  x.__repr__() &lt;==&gt; repr(x)
  <dl><dt></dt><dd>
    <dl><dt><b>Returns:</b></dt>
      <dd>
<pre class="literalblock">
repr(x)
</pre>
      </dd>
    </dl>
    <dl><dt><b>Overrides:</b></dt>
      <dd><a href="__builtin__.object-class.html#__repr__"><code>__builtin__.object.__repr__</code></a></dd>
    </dl>
  </dd></dl>
</td></tr></table>

<a name="__setitem__"></a>
<table width="100%" class="func-details" bgcolor="#e0e0e0"><tr><td>
  <h3><span class="sig"><span class="sig-name">__setitem__</span>(<span class=sig-arg>x</span>,
          <span class=sig-arg>i</span>,
          <span class=sig-arg>y</span>)</span>
    <br /><i>(Index assignment operator)</i>
  </h3>
  x.__setitem__(i, y) &lt;==&gt; x[i]=y
  <dl><dt></dt><dd>
    <dl><dt><b>Returns:</b></dt>
      <dd>
<pre class="literalblock">
x[i]=y
</pre>
      </dd>
    </dl>
  </dd></dl>
</td></tr></table>

<a name="clear"></a>
<table width="100%" class="func-details" bgcolor="#e0e0e0"><tr><td>
  <h3><span class="sig"><span class="sig-name">clear</span>(<span class=sig-arg>D</span>)</span>
  </h3>
  D.clear() -&gt; None. Remove all items from D.
  <dl><dt></dt><dd>
    <dl><dt><b>Returns:</b></dt>
      <dd>
<pre class="literalblock">
None
</pre>
      </dd>
    </dl>
  </dd></dl>
</td></tr></table>

<a name="copy"></a>
<table width="100%" class="func-details" bgcolor="#e0e0e0"><tr><td>
  <h3><span class="sig"><span class="sig-name">copy</span>(<span class=sig-arg>D</span>)</span>
  </h3>
  D.copy() -&gt; a shallow copy of D
  <dl><dt></dt><dd>
    <dl><dt><b>Returns:</b></dt>
      <dd>
<pre class="literalblock">
a shallow copy of D
</pre>
      </dd>
    </dl>
  </dd></dl>
</td></tr></table>

<a name="get"></a>
<table width="100%" class="func-details" bgcolor="#e0e0e0"><tr><td>
  <h3><span class="sig"><span class="sig-name">get</span>(<span class=sig-arg>D</span>,
          <span class=sig-arg>k</span>,
          <span class=sig-arg>d</span>=<span class=sig-default>...</span>)</span>
  </h3>
  D.get(k[,d]) -&gt; D[k] if k in D, else d. d defaults to None.
  <dl><dt></dt><dd>
    <dl><dt><b>Returns:</b></dt>
      <dd>
<pre class="literalblock">
D[k] if k in D, else d
</pre>
      </dd>
    </dl>
  </dd></dl>
</td></tr></table>

<a name="has_key"></a>
<table width="100%" class="func-details" bgcolor="#e0e0e0"><tr><td>
  <h3><span class="sig"><span class="sig-name">has_key</span>(<span class=sig-arg>D</span>,
          <span class=sig-arg>k</span>)</span>
  </h3>
  D.has_key(k) -&gt; True if D has a key k, else False
  <dl><dt></dt><dd>
    <dl><dt><b>Returns:</b></dt>
      <dd>
<pre class="literalblock">
True if D has a key k, else False
</pre>
      </dd>
    </dl>
  </dd></dl>
</td></tr></table>

<a name="items"></a>
<table width="100%" class="func-details" bgcolor="#e0e0e0"><tr><td>
  <h3><span class="sig"><span class="sig-name">items</span>(<span class=sig-arg>D</span>)</span>
  </h3>
  D.items() -&gt; list of D's (key, value) pairs, as 2-tuples
  <dl><dt></dt><dd>
    <dl><dt><b>Returns:</b></dt>
      <dd>
<pre class="literalblock">
list of D's (key, value) pairs, as 2-tuples
</pre>
      </dd>
    </dl>
  </dd></dl>
</td></tr></table>

<a name="iteritems"></a>
<table width="100%" class="func-details" bgcolor="#e0e0e0"><tr><td>
  <h3><span class="sig"><span class="sig-name">iteritems</span>(<span class=sig-arg>D</span>)</span>
  </h3>
  D.iteritems() -&gt; an iterator over the (key, value) items of D
  <dl><dt></dt><dd>
    <dl><dt><b>Returns:</b></dt>
      <dd>
<pre class="literalblock">
an iterator over the (key, value) items of D
</pre>
      </dd>
    </dl>
  </dd></dl>
</td></tr></table>

<a name="iterkeys"></a>
<table width="100%" class="func-details" bgcolor="#e0e0e0"><tr><td>
  <h3><span class="sig"><span class="sig-name">iterkeys</span>(<span class=sig-arg>D</span>)</span>
  </h3>
  D.iterkeys() -&gt; an iterator over the keys of D
  <dl><dt></dt><dd>
    <dl><dt><b>Returns:</b></dt>
      <dd>
<pre class="literalblock">
an iterator over the keys of D
</pre>
      </dd>
    </dl>
  </dd></dl>
</td></tr></table>

<a name="itervalues"></a>
<table width="100%" class="func-details" bgcolor="#e0e0e0"><tr><td>
  <h3><span class="sig"><span class="sig-name">itervalues</span>(<span class=sig-arg>D</span>)</span>
  </h3>
  D.itervalues() -&gt; an iterator over the values of D
  <dl><dt></dt><dd>
    <dl><dt><b>Returns:</b></dt>
      <dd>
<pre class="literalblock">
an iterator over the values of D
</pre>
      </dd>
    </dl>
  </dd></dl>
</td></tr></table>

<a name="keys"></a>
<table width="100%" class="func-details" bgcolor="#e0e0e0"><tr><td>
  <h3><span class="sig"><span class="sig-name">keys</span>(<span class=sig-arg>D</span>)</span>
  </h3>
  D.keys() -&gt; list of D's keys
  <dl><dt></dt><dd>
    <dl><dt><b>Returns:</b></dt>
      <dd>
<pre class="literalblock">
list of D's keys
</pre>
      </dd>
    </dl>
  </dd></dl>
</td></tr></table>

<a name="pop"></a>
<table width="100%" class="func-details" bgcolor="#e0e0e0"><tr><td>
  <h3><span class="sig"><span class="sig-name">pop</span>(<span class=sig-arg>D</span>,
          <span class=sig-arg>k</span>,
          <span class=sig-arg>d</span>=<span class=sig-default>...</span>)</span>
  </h3>
  If key is not found, d is returned if given, otherwise KeyError is 
  raised
  <dl><dt></dt><dd>
    <dl><dt><b>Returns:</b></dt>
      <dd>
<pre class="literalblock">
v, remove specified key and return the corresponding value
</pre>
      </dd>
    </dl>
  </dd></dl>
</td></tr></table>

<a name="popitem"></a>
<table width="100%" class="func-details" bgcolor="#e0e0e0"><tr><td>
  <h3><span class="sig"><span class="sig-name">popitem</span>(<span class=sig-arg>D</span>)</span>
  </h3>
  2-tuple; but raise KeyError if D is empty
  <dl><dt></dt><dd>
    <dl><dt><b>Returns:</b></dt>
      <dd>
<pre class="literalblock">
(k, v), remove and return some (key, value) pair as a
</pre>
      </dd>
    </dl>
  </dd></dl>
</td></tr></table>

<a name="setdefault"></a>
<table width="100%" class="func-details" bgcolor="#e0e0e0"><tr><td>
  <h3><span class="sig"><span class="sig-name">setdefault</span>(<span class=sig-arg>D</span>,
          <span class=sig-arg>k</span>,
          <span class=sig-arg>d</span>=<span class=sig-default>...</span>)</span>
  </h3>
  D.setdefault(k[,d]) -&gt; D.get(k,d), also set D[k]=d if k not in 
  D
  <dl><dt></dt><dd>
    <dl><dt><b>Returns:</b></dt>
      <dd>
<pre class="literalblock">
D.get(k,d), also set D[k]=d if k not in D
</pre>
      </dd>
    </dl>
  </dd></dl>
</td></tr></table>

<a name="update"></a>
<table width="100%" class="func-details" bgcolor="#e0e0e0"><tr><td>
  <h3><span class="sig"><span class="sig-name">update</span>(<span class="sig-vararg">...</span>)</span>
  </h3>
  D.update(E, **F) -&gt; None. Update D from E and F: for k in E: D[k] 
  = E[k] (if E has keys else: for (k, v) in E: D[k] = v) then: for k in 
  F: D[k] = F[k]
  <dl><dt></dt><dd>
  </dd></dl>
</td></tr></table>

<a name="values"></a>
<table width="100%" class="func-details" bgcolor="#e0e0e0"><tr><td>
  <h3><span class="sig"><span class="sig-name">values</span>(<span class=sig-arg>D</span>)</span>
  </h3>
  D.values() -&gt; list of D's values
  <dl><dt></dt><dd>
    <dl><dt><b>Returns:</b></dt>
      <dd>
<pre class="literalblock">
list of D's values
</pre>
      </dd>
    </dl>
  </dd></dl>
</td></tr></table>
<br />


<!-- =========== START OF NAVBAR =========== -->
<table class="navbar" border="0" width="100%" cellpadding="0" bgcolor="#a0c0ff" cellspacing="0">
  <tr valign="center">
    <th class="navbar">&nbsp;&nbsp;&nbsp;<a class="navbar" href="gvn-module.html">Home</a>&nbsp;&nbsp;&nbsp;</th>
    <th class="navbar">&nbsp;&nbsp;&nbsp;<a class="navbar" href="trees.html">Trees</a>&nbsp;&nbsp;&nbsp;</th>
    <th class="navbar">&nbsp;&nbsp;&nbsp;<a class="navbar" href="indices.html">Index</a>&nbsp;&nbsp;&nbsp;</th>
    <th class="navbar">&nbsp;&nbsp;&nbsp;<a class="navbar" href="help.html">Help</a>&nbsp;&nbsp;&nbsp;</th>
    <th class="navbar" align="right" width="100%">
      <table border="0" cellpadding="0" cellspacing="0">
      <tr><th class="navbar" align="center">
        <p class="nomargin">
          <a class="navbar" target="_top" href="http://code.google.com/p/gvn/">Project&nbsp;Homepage</a>
      </p></th></tr></table>
    </th>
  </tr>
</table>

<table border="0" cellpadding="0" cellspacing="0" width="100%">
  <tr>
    <td align="left"><font size="-2">Generated by Epydoc 2.1 on Tue Jul 17 16:51:46 2007</font></td>
    <td align="right"><a href="http://epydoc.sourceforge.net"
                      ><font size="-2">http://epydoc.sf.net</font></a></td>
  </tr>
</table>
</body>
</html>
